home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / m2posx10.zoo / m2posix.10 / src / cstr.dpp < prev    next >
Encoding:
Modula Definition  |  1993-10-09  |  6.9 KB  |  143 lines
  1. DEFINITION MODULE cstr;
  2. __DEF_SWITCHES__
  3. #ifdef HM2
  4. #ifdef __LONG_WHOLE__
  5. (*$!i+: Modul muss mit $i- uebersetzt werden! *)
  6. (*$!w+: Modul muss mit $w- uebersetzt werden! *)
  7. #else
  8. (*$!i-: Modul muss mit $i+ uebersetzt werden! *)
  9. (*$!w-: Modul muss mit $w+ uebersetzt werden! *)
  10. #endif
  11. #endif
  12. (*****************************************************************************)
  13. (* Diese Prozeduren dienen der Bearbeitung von Strings nach 'C'-Konvention,  *)
  14. (* d.h. sie sind IMMER (einzige Ausnahme: "strncpy()") mit einem Nullbyte    *)
  15. (* abgeschlossen und werden durch einen Zeiger auf ihren ersten Buchstaben   *)
  16. (* repraesentiert. Die Prozeduren fangen Zeiger mit dem Wert NULL (nicht NIL)*)
  17. (* ab.                                                                       *)
  18. (* "strerror()" arbeitet mit einem M2-String, da kein Bedarf besteht, den    *)
  19. (* Fehlertext als 'C'-String zu verarbeiten.                                 *)
  20. (* Laengenangaben werden zwar durch den Typ 'sizeT' repraesentiert, es       *)
  21. (* duerfen aber nur Werte im Bereich 'StrRange' benutzt werden.              *)
  22. (* --------------------------------------------------------------------------*)
  23. (* 18-Sep-93, Holger Kleinschmidt                                            *)
  24. (*****************************************************************************)
  25.  
  26. FROM types IMPORT
  27. (* TYPE *) sizeT, StrPtr, StrRange;
  28.  
  29. (*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*)
  30.  
  31.  PROCEDURE strlen ((* EIN/ -- *) str : StrPtr ): sizeT;
  32.  
  33. (*---------------------------------------------------------------------------
  34.  | Liefert die Laenge von <str>.                                             |
  35.   ---------------------------------------------------------------------------*)
  36.  
  37.  
  38.  PROCEDURE strcpy ((* EIN/ -- *) dst : StrPtr;
  39.                    (* EIN/ -- *) src : StrPtr );
  40.  
  41.  PROCEDURE strncpy ((* EIN/ -- *) dst : StrPtr;
  42.                     (* EIN/ -- *) src : StrPtr;
  43.                     (* EIN/ -- *) len : sizeT  );
  44.  
  45. (*---------------------------------------------------------------------------
  46.  | Zuweisung: dst := src.                                                    |
  47.  | "strncpy()" kopiert im Gegensatz zu "strcpy()" genau <len> Zeichen        |
  48.  | nach <dst>^. Falls <src>^ kuerzer als <len> ist, wird <dst>^ mit Nullbytes|
  49.  | auf <len> Zeichen aufgefuellt, falls jedoch <src>^ groesser oder gleich   |
  50.  | als <len> Zeichen ist, wird <dst>^ NICHT mit einem Nullbyte abgeschlossen!|
  51.   ---------------------------------------------------------------------------*)
  52.  
  53.  
  54.  PROCEDURE strcat ((* EIN/ -- *) dst : StrPtr;
  55.                    (* EIN/ -- *) src : StrPtr );
  56.  
  57.  PROCEDURE strncat ((* EIN/ -- *) dst : StrPtr;
  58.                     (* EIN/ -- *) src : StrPtr;
  59.                     (* EIN/ -- *) len : sizeT  );
  60.  
  61. (*---------------------------------------------------------------------------
  62.  | Konkatenation: dst := dst ++ src.                                         |
  63.  | "strncat()" kopiert hoechstens <len> Zeichen von <src> ans Ende von <dst>,|
  64.  | <src> wird aber auf jeden Fall mit einem Nullbyte abgeschlossen.          |
  65.   ---------------------------------------------------------------------------*)
  66.  
  67.  
  68.  PROCEDURE strcmp ((* EIN/ -- *) str1 : StrPtr;
  69.                    (* EIN/ -- *) str2 : StrPtr ): INTEGER;
  70.  
  71.  PROCEDURE strncmp ((* EIN/ -- *) str1  : StrPtr;
  72.                     (* EIN/ -- *) str2  : StrPtr;
  73.                     (* EIN/ -- *) len   : sizeT  ): INTEGER;
  74.  
  75. (*---------------------------------------------------------------------------
  76.  | Vergleichen <str1> und <str2> zeichenweise miteinander. Wenn beide Strings|
  77.  | gleich sind, wird Null geliefert; ist ein Zeichen aus <str1> kleiner als  |
  78.  | das entsprechende Zeichen in <str2> wird ein Wert kleiner Null geliefert; |
  79.  | ist ein Zeichen groesser, wird ein Wert groesser Null geliefert.          |
  80.  | "strncmp()" vergleicht hoechstens <len> Zeichen miteinander.              |
  81.   ---------------------------------------------------------------------------*)
  82.  
  83.  
  84.  PROCEDURE strchr ((* EIN/ -- *) s : StrPtr;
  85.                    (* EIN/ -- *) c : CHAR   ): StrPtr;
  86.  
  87.  PROCEDURE strrchr ((* EIN/ -- *) s : StrPtr;
  88.                     (* EIN/ -- *) c : CHAR   ): StrPtr;
  89.  
  90. (*---------------------------------------------------------------------------
  91.  | Suchen das erste bzw. letzte Auftreten von <c> in <s>. Falls <c> gefunden |
  92.  | wird, wird ein Zeiger auf die Adresse in <s> geliefert, sonst NULL.       |
  93.   ---------------------------------------------------------------------------*)
  94.  
  95.  
  96.  PROCEDURE strstr ((* EIN/ -- *) str : StrPtr;
  97.                    (* EIN/ -- *) pat : StrPtr ): StrPtr;
  98.  
  99. (*---------------------------------------------------------------------------
  100.  | Liefert die Adresse des ersten Auftretens von <pat> in <str>, sonst NULL. |
  101.   ---------------------------------------------------------------------------*)
  102.  
  103.  
  104.  PROCEDURE strpbrk ((* EIN/ -- *) str : StrPtr;
  105.                     (* EIN/ -- *) brk : StrPtr ): StrPtr;
  106.  
  107. (*---------------------------------------------------------------------------
  108.  | Liefert die Adresse des ersten Auftretens eines Zeichens aus <brk> in <s>,|
  109.  | sonst NULL.                                                               |
  110.   ---------------------------------------------------------------------------*)
  111.  
  112.  
  113.  PROCEDURE strerror ((* EIN/ -- *)     errnum : INTEGER;
  114.                      (* -- /AUS *) VAR errstr : ARRAY OF CHAR );
  115.  
  116. (*--------------------------------------------------------------------------
  117.  | Wandelt den Fehlercode <errnum> in einen kurzen Fehlertext <errstr>.     |
  118.   --------------------------------------------------------------------------*)
  119.  
  120.  
  121.  
  122.  PROCEDURE AssignM2ToC ((* EIN/ -- *) REF strM2 : ARRAY OF CHAR;
  123.                         (* EIN/ -- *)     sizeC : StrRange;
  124.                         (* EIN/ -- *)     strC  : StrPtr        );
  125.  
  126.  PROCEDURE AssignCToM2 ((* EIN/ -- *)     strC  : StrPtr;
  127.                         (* -- /AUS *) VAR strM2 : ARRAY OF CHAR );
  128.  
  129. (*---------------------------------------------------------------------------
  130.  | "AssignM2ToC()" und "AssignCToM2()" wandeln die MODULA- und C-Stringre-   |
  131.  | praesentationen ineinander um. Falls <strM2> bei "AssignCToM2()" nicht    |
  132.  | gross genug ist, wird entsprechend gekuerzt.                              |
  133.  | <strC> muss bei "AssignM2ToC" auf einen Speicherbereich ausreichender     |
  134.  | Laenge zeigen. Es werden maximal <size> Zeichen kopiert. <size> bezeichnet|
  135.  | den Platz in <strC>^. Falls <strM2> groesser oder gleich <sizeC> Zeichen  |
  136.  | ist, werden genau <sizeC> Zeichen nach <strC> kopiert, aber NICHT mit     |
  137.  | einem Nullbyte abgeschlossen. Nur wenn <strM2> kuerzer als <sizeC> Zeichen|
  138.  | ist, wird <strC> mit einem Nullbyte abgeschlossen. Diese Prozedur ent-    |
  139.  | spricht damit "strncpy()".                                                |
  140.   ---------------------------------------------------------------------------*)
  141.  
  142. END cstr.
  143.